Synchronization of web service endpoints in a multi-master synchronization environment

ABSTRACT

A Web service synchronization protocol is provided that sets forth the metadata and messaging by which endpoints roam, share and synchronize common information with one another in a multi-master networked computing ecosystem. A general SOAP-based protocol is defined for synchronizing data between two endpoints where one or more of the endpoints supports a Web service. Defining messaging for knowledge-based transfers using XML Web services, the protocol allows devices, services and applications to synchronize through firewalls, allows for flexibility by allowing any common set or subset of information across endpoints and allows for extensibility by not prescribing the schema of the actual data being synchronized at the endpoints.

CROSS-REFERENCE TO RELATED APPLICATIONS

This application is a continuation of U.S. patent application Ser. No.11/859,931, filed Sep. 24, 2007, entitled “SYNCHRONIZATION OF WEBSERVICE ENDPOINTS IN A MULTI-MASTER SYNCHRONIZATION ENVIRONMENT,” whichis incorporated herein by reference in its entirety.

TECHNICAL FIELD

The subject disclosure relates to a synchronization protocol for looselycoupled devices to synchronize with one another in a multi-mastersynchronization environment.

BACKGROUND

The popularity of mobile computing and communications devices hascreated a corresponding wish for the ability to deliver and receiveinformation whenever wanted by users. Put simply, users want ubiquitousaccess to information and applications from a variety of devices,wherever, whenever, and whatever the devices' capabilities, and inaddition, users want to be able to access and update such information onthe fly, and they want guarantees that the data is as correct and up todate as can be.

There are a variety of distributed data systems that attempt to havedevices and objects share replicas of data with one another. Forinstance, music sharing systems may synchronize music between a PC, aCell phone, a gaming console and an MP3 player. Email data may besynchronized among a work server, a client PC, and a portable emaildevice. However, today, to the extent such devices synchronize a set ofcommon information among one another, the synchronization takes placeaccording to a static setup among the devices. However, when thesedevices become disconnected frequently or intermittently, i.e., whenthey are loosely coupled such that they may become disconnected fromcommunications with each other, e.g., when a cell phone is in a tunnel,or when the number of devices to be synchronized is dynamic, it becomesdesirable to have a topology independent way for the devices todetermine what changes each other device needs when they re-connect toone another, or as they join the network.

Today, as shown in FIG. 1, there are various examples where a masternode 100 synchronizes in a dedicated manner with a client node 110, suchas when an email server synchronizes with an email client. Due to thededicated synchronization between the two devices, the information 102needed to synchronize between the two devices can be tracked by themaster node 100. Such information 102 can also optionally be tracked byclient node 110 as well, however, when the connection between masternode 100 and client node 110 becomes disconnected at times, and when thenumber of synchronizing devices increases, tracking the necessaryinformation of the common information that each device needs across allof those devices becomes a difficult problem.

Current solutions often base their synchronization semantics solely onclocks or logical watermarks for a specific node (e.g., the emailserver), as opposed to any node. These systems can work well in cases ofa single connecting node or master. However, they run into problems whenthe topology or pattern in which the nodes connect changesunpredictably.

Other systems build proprietary synchronization models for specifickinds of data objects, tracking an enormous amount of primitive metadataspecific to the data format across the devices in order to handle theproblem. For instance, to synchronize objects of a particular Wordprocessing document format, a lot of overhead and complexity must gointo representing a document and its fundamental primitives as theychange over time, and representing that information efficiently to otherdevices wishing to synchronize according to a common set of Wordprocessing documents. In addition to such systems being expensive andcomplex to build and non-extendible due to the custom data format uponwhich they are based, such systems are inherently unscalable due tolarge amounts of metadata that must be generated, analyzed and tracked.

In addition, the solutions only apply to the one specific domain, e.g.,Word processing documents. When synchronization objects of all kinds areconsidered, e.g., pictures, videos, emails, documents, database stores,etc., one can see that implementing custom synchronization solutionsbased on each object type for tracking evolution of such objects acrossall devices in a multi-master environment is unworkable today.Accordingly, such solutions cannot be said to decouple thesynchronization semantics from the data semantics.

Thus, there is a need for node-independent synchronization knowledgewhen computers in a topology change the way they connect to each otheror as the number of computers grows. For instance, with a media player,it might be desirable to synchronize among multiple computers andmultiple websites. In most instances, most applications can onlysynchronize data between a few well-known endpoints (home PC and mediaplayer). As the device community evolves over time for a user of themedia player application, however, the need for data synchronizationflexibility for the music library utilized by the devices increases,thereby creating the need for a more robust system.

The need becomes even more complex when one considers the growth of Webservices endpoints that are increasingly involved in receiving,generation, processing, storage, updating and transmitting data,generating a variety of network traffic to or from devices. In thisregard, in parallel with the evolution of synchronization needs ofdevices, a coincident trend is that more data is being created, stored,manipulated, transmitted, etc., by Web services, i.e., software systemsdesigned to support interoperable machine to machine interaction over anetwork. Typically, Web services are Web APIs that can be accessed overa network by client devices, such as the Internet, and executed on aremote system hosting the requested services. However, there is no wayto synchronize with Web services as a generic endpoint as part of aloosely coupled multi-master synchronization environment, either.

In this respect, from a synchronization standpoint in a multi-masterenvironment, Web services implementations of an endpoint that cansynchronize to any device would be a valuable scenario since two devicesmay not be able to connect directly, but may be able to connect via acommon Web services endpoint. In this regard, complications arise whenattempting to synchronize among loosely coupled devices and Web serviceswhen there is no mechanism for understanding, independent of the objectsbeing synchronized, the collective knowledge of all of the set ofdevices that are connected, as those devices invariably connect anddisconnect from one or more networks that couple them all together aspart of an evolving and devolving network topology of nodes.

Thus, what is needed is an efficient, simple and universal mechanism forrepresenting what each of the connected devices know and do not know, sothat the common information can be pieced together to the maximum extentpermitted by the collective knowledge of the individuals/devices.Moreover, there is a need to accommodate Web services as asynchronization node in such a multi-master system to help facilitateloosely connected systems of nodes to describe the data, and versions ofthe data, they have, to describe where they received the data, and tofurther describe what data they need from another node involved in theconversation.

Additional detail about these and other deficiencies in the currentstate of synchronization among loosely coupled devices may becomeapparent from the description of the various embodiments of theinvention that follows.

SUMMARY

A Web service synchronization protocol is provided that sets forth themetadata and messaging by which endpoints roam, share and synchronizewith one another in a multi-master networked computing ecosystem. Invarious non-limiting embodiments, a general SOAP-based protocol forsynchronizing data between two endpoints is provided where one or moreof the endpoints support a Web service. The protocol defines messagingfor knowledge-based transfers using XML Web services, allowing devices,services and applications to synchronize through firewalls in a flexiblemanner that permits any common set or subset of information acrossendpoints and allowing for extensibility by not prescribing the schemaof the actual data being synchronized at the endpoints.

A simplified summary is provided herein to help enable a basic orgeneral understanding of various aspects of exemplary, non-limitingembodiments that follow in the more detailed description and theaccompanying drawings. This summary is not intended, however, as anextensive or exhaustive overview. Instead, the sole purpose of thissummary is to present some concepts related to some exemplarynon-limiting embodiments of the invention in a simplified form as aprelude to the more detailed description of the various embodiments ofthe invention that follows.

BRIEF DESCRIPTION OF THE DRAWINGS

The Web services synchronization protocol and techniques forsynchronizing using the protocol are further described with reference tothe accompanying drawings in which:

FIG. 1 illustrates a dedicated synchronization system that providessynchronization between two well defined endpoints of the system;

FIG. 2A is a block diagram illustrating an exemplary multi-mastersynchronization environment where some nodes may come into contact withone another infrequently or not at all;

FIG. 2B illustrates an exemplary scenario wherein a node synchronizeswith a Web service endpoint in accordance with a Web servicessynchronization protocol in accordance with non-limiting embodiments ofthe invention;

FIG. 2C illustrates an exemplary scenario wherein a Web service endpointsynchronizes with a node in accordance with a Web servicessynchronization protocol in accordance with non-limiting embodiments ofthe invention;

FIG. 2D illustrates an exemplary scenario wherein a nodes of amulti-master synchronization environment achieve a richer exchange ofknowledge according to non-limiting embodiments of the Web servicessynchronization protocol of the invention;

FIG. 3A illustrates exemplary non-limiting knowledge exchange betweenfour nodes of a loosely connected network of nodes;

FIG. 3B illustrates exemplary non-limiting knowledge exchange betweenfour nodes of a loosely connected network of nodes when some of thedevices become disconnected from one another;

FIGS. 4A, 4B and 4C illustrate exemplary knowledge exchange in thecontext of multiple objects shared among nodes of a network;

FIG. 5A is an exemplary non-limiting flow diagram illustrating theprocess for knowledge exchange in the context of multiple objects sharedamong nodes of a network;

FIG. 5B is a general architecture illustrating the framework forrequesting and conveying changes based on knowledge and partialknowledge;

FIG. 6 is a general architecture for Web services communications bynodes and/or Web service providers in accordance with non-limitingembodiments of a Web service synchronization protocol of the invention;

FIGS. 7A, 7B, 7C and 7D illustrate different knowledge exchangemessaging patterns that can be implemented with flexible Web servicessynchronization protocol communications of non-limiting embodiments ofthe invention:

FIG. 8 illustrates an example where two different versions of knowledgeare represented according to different schema, but synchronizedaccording to a common representation of knowledge as enabled by partialknowledge representations in accordance with non-limiting embodiments ofthe invention;

FIG. 9 is an exemplary non-limiting flow diagram illustrating theprocess for knowledge and/or partial knowledge exchange in the contextof multiple objects shared among nodes and/or a Web service endpoint ofa network in accordance with non-limiting embodiments of the invention;

FIG. 10 is a block diagram of an exemplary non-limiting implementationof a device for performing a knowledge exchange with another node or Webservice endpoint;

FIG. 11 is a block diagram representing an exemplary non-limitingnetworked environment in which the present invention may be implemented;and

FIG. 12 is a block diagram representing an exemplary non-limitingcomputing system or operating environment in which the present inventionmay be implemented.

DETAILED DESCRIPTION Overview

As described in the background, given today's disconnected anddistributed manner of computing, what is desired is the ability to useapplications and information on a device, and synchronize any updateswith the applications and information back at the office, or withdevices of a home network, etc. In this regard, the scenarios forsynchronization are limitless.

In a multi-master synchronization environment, the ability tosynchronize is desirable anywhere and anytime a device comes intocontact with one or more nodes of a loosely coupled set of nodes,including Web services endpoints. However, it is desirable to undergo anefficient knowledge exchange without tracking burdensome amounts dataspecific metadata. Unfortunately, networked data does not today supportsynchronization with any mobile device and mobile devices do not supportsynchronization with any networked data. Rather, there is aproliferation of different, proprietary data synchronization protocolsfor mobile devices. Each of these protocols is only available forselected transports, implemented on a selected subset of devices, andable to access a small set of networked data. The absence of a singlesynchronization standard poses many problems for end users, devicemanufacturers, application developers, and service providers.

Mobile computing thus has a pervasive issue—data synchronization. Allthe popular mobile devices—handheld computers, mobile phones, pagers,laptops—synchronize their data with network applications, musicapplications, desktop calendars, and other locations where informationis stored. This ability to access and update such information on the flyunder conditions of intermittent connectivity, however, is fast becominga pervasive part of mobile computing. Yet, today, almost every deviceuses a different technology for performing data synchronization.

Thus, any distributed data system that wishes to share commoninformation across multiple loosely coupled devices including Webservices endpoints needs an efficient way to represent what changes tothe common information of which they are aware and what changes of whichthey are unaware.

In consideration of these needs, in various non-limiting embodiments,the invention provides a data type agnostic synchronization protocolthat enables Web service endpoints to participate in synchronization ofa common set or subset of information among nodes and other Web serviceendpoints in a multi-master synchronization environment. A datasynchronization protocol is provided that defines communications for adata synchronization session when a device is connected to another nodeor Web service endpoint in a network. The protocol supports a knowledgeframework for synchronizing among nodes including identification andversioning of objects and common protocol commands for an efficientknowledge exchange to synchronize local and network data.

As shown in FIG. 2A, a representative multi-master synchronizationenvironment might be represented by a user's desire to store music, andsynchronize the user's music across all of the user's devices, whereverand whenever the music collection changes. For instance, at the user'shouse, the user may have an MP3 player 220 and a computing device 230that can synchronize with one another. Similarly, at the user's place ofemployment, the user might have another computer device 200 and a mobilephone 240. In this respect, the user has no trouble synchronizing themobile phone 240 with device 200 when in contact with it, but as part ofcompany policy, the user cannot carry the mobile phone 240 away fromwork. Thus, in this hypothetical scenario, the devices at home cansynchronize via a knowledge based exchange and the devices at work cansynchronize via a knowledge based exchange, however, there is no bridgeto transfer knowledge from work devices to home devices, or vice versa.Thus, what would be desirable would be able to synchronize to a Webservice endpoint. The protocol of the invention, in various non-limitingembodiments described in more detail below, enables such a knowledgebased exchange via XML messaging with a Web service endpoint to giveadditional synchronization options and flexibility in a multi-mastersynchronization environment.

As shown in FIG. 2B, leveraging an efficient knowledge basedsynchronization framework for exchanging understanding about a commonset or subset of information among nodes of a multi-mastersynchronization ecosystem, a knowledge based exchange with a Web serviceendpoint is enabled. As illustrated, PC 200 includes knowledge 202,which includes a set of objects and their versions (e.g., timestamp). Byinvoking a Web service synchronization request of Web service endpoint210, PC 200 sends its knowledge 202 to Web service 210, which in turnhas its own knowledge 212 to compare against knowledge 202. In return,Web service 210 returns knowledge 212 to PC 200. The details of theknowledge exchange framework are described in more detail below. In thisregard, a Web services synchronization protocol 205 is provided thatdefines the way PC 200 sends XML messages to Web service 210 to have aknowledge based synchronization based on knowledge 202 and 212. As aresult, Web service endpoint 210 picks up any knowledge 202 understoodby the client that the Web service endpoint 210 does not appreciate andvice versa.

As a result of the exchange with Web service endpoint 210, knowledge 212is updated to knowledge 212′, as shown in FIG. 2C, where device 200 ofFIG. 2B becomes disconnected, but MP3 Player 220 becomes connected tothe Web service 210, making a request to synchronize with the Webservice endpoint 210 with the Web service synchronization protocol 205.In this regard, a knowledge exchange occurs with respect to knowledge222 and 212′ in which case MP3 Player 220 learns that part of knowledge212′ that MP3 Player 220 does not know, and vice versa.

In this way, as shown in FIG. 2D, a Web service endpoint 210, followingthe same synchronization framework for representing knowledge amongnodes that connect, disconnect and synchronize in a multi-mastersynchronization environment, can synchronize with any of the nodes, andthereby facilitate the learning of knowledge across all of a user'snodes, even where some nodes never connect directly with other nodes ofthe multi-master synchronization group.

Efficient Knowledge Representation and Exchange

As a prelude to describing the synchronization protocol forsynchronizing data or subsets of data among nodes in a multi-mastersynchronization environment including synchronization with Web serviceendpoints in accordance with various non-limiting embodiments of theinvention, in this section, an overview is presented of a generalmechanism for efficiently representing knowledge in data synchronizationsystems. The general mechanism includes (1) an efficient exchange ofknowledge between connected devices by requiring only the minimum dataneeded by a first node from a second node to be sent, (2) the ability toefficiently and correctly recognize disagreements over the state ofdata, i.e., conflicts, between a first node and a second node, (3) theability to synchronize an arbitrary number of nodes and (4) the abilityto synchronize any node via any other node, i.e., the ability to work ina peer to peer, multi-master synchronization environment.

With the general mechanism, any number of changes can be made to someinformation that is to be shared between the two devices. At any timethey become connected, by exchanging their knowledge with one another,they become aware of at least the minimum amount of information neededto reconstruct what each other knows and doesn't know to facilitate ofchanges between the devices. It is noted that where more than twodevices are involved, knowledge may be incomplete knowledge of a greaterbase of information to be shared, but as more knowledge is shared aroundthe multiple devices, collective knowledge continues to be accrued bythe devices as they connect to the other devices over time.

Advantageously, in various non-limiting embodiments, the inventionoperates to perform synchronization for a set of devices, or, asdescribed below, a subset of devices, all interested in maintaining thelatest versions of a set of objects, but also allows such devices tocome into connection and out of connection with the other objects of theset. Whenever a device comes back into connection with other device(s)of the set of devices via one or more networks, the device regainscollective knowledge that is as up to date as the other device(s)represent with their collective knowledge. In this fashion, even looselyconnected devices may come into and out of contact with a set ofdevices, and then relearn all the knowledge missed by coming intocontact with any set of devices that possess the latest set ofcollective knowledge.

FIG. 3A illustrates that knowledge exchanges are generalizable, orscalable, to any number of devices. As shown, four devices 300, 310, 320and 330 are shown with knowledge representations 302, 312, 322 and 332that respectively indicate what each device knows and doesn't know abouta set of common information to be shared across the devices.

Advantageously, as shown by FIG. 3B, even where connections in thenetwork become disconnected, a complete set of knowledge can nonethelessbe gained by all of the devices 300, 310, 320, and 330, as long as atleast one connection directly or indirectly exists to the other devices.For instance, as shown, knowledge 332 of device 330 still reaches device300 via the knowledge exchange with device 320, then via the knowledgeexchange between device 320 and 310, and finally via the knowledgeexchange between device 310 and 300.

With more devices sharing knowledge about common information to beshared, all of the devices benefit because knowledge exchange(s) inaccordance with various non-limiting embodiments of the invention of theinvention are agnostic about from which device collective knowledgecomes. The devices each independently operate to try to gain as muchknowledge about information to be shared among the devices from any ofthe other devices to which it is connected.

In exemplary non-limiting detail, a method is described in furtherdetail for two nodes to engage in a conversation and at the end of theconversation to have equivalent knowledge for the concerned data set.The method is scalable beyond two nodes by creating a knowledge exchangecapability for each new device entering the peer-to-peer network.

Thus, as shown in FIG. 4A, node 400 of a peer-to-peer network having anynumber of nodes wants to exchange data with Node 410. Node A begins byrequesting changes from Node 410 and in order to do so Node 400 sendsits knowledge (represented as K_(N400)) to Node 410 as shown.

Knowledge of a device or node is represented by labeling each object tobe shared among devices with a letter identifier, and then the trailingnumber represents the latest version for this object. For instance,KN₄₀₀ as shown in FIG. 4A includes objects A, B, C and D each to besynchronized between nodes 400 and 410, and the number following each ofthe objects represents the latest version of the object known on thedevice. For instance, knowledge KN₄₀₀ at a time t=1 includes the 5^(th)version of A, the 4^(th) version of B, the 7^(th) version of C, and the1^(th) version of D, notated as A4, B3, C6, D0 in FIG. 4A. In contrast,knowledge K_(N410) of node 410 at a time t=1 may include the 4^(th)version of A, the 7^(th) version of B, the 7^(th) version of C, and the3^(rd) version of D, notated as A3, B6, C6, D2 in FIG. 4A.

As shown in FIG. 4B, at time T=2, node 410 compares knowledge K_(N400)received from node 400 against its own knowledge K_(N410) and determineswhat needs to be sent to node 400. In this example, as a result, node410 will send node 400 the changes relating to B and D since node 400'sknowledge of B3, D0 is behind node 410's knowledge of B6 and D2. Whennode 410 sends node 400 the changes between B6 and B3, and the changesbetween D2 and D0, it also sends along the latest version of knowledgeK_(N410) it has (reflecting whenever the last change on node 410 wasmade).

As shown in FIG. 4C, representing time t=3, sending knowledge K_(N410)to node 400 allows node 400 to detect conflicts (e.g., store them forlater resolution) if it later finds out that both node 400 and node 410made a change to an object while they were on the same version. Thisallows for autonomous updating, efficient enumeration, but also correctconflict detection when the nodes meet and exchange changes. Forinstance, in the example, if C6 is not the same object in both knowledgeKN₄₁₀ and K_(N410), e.g., if both independently evolved from C5 to C6,then which C6 is the correct C6 can be set aside for conflictresolution, e.g., according to pre-set policy resolution that befits thesynchronization scenario and devices involved.

An exemplary knowledge exchange process between any two nodes of adistributed multi-master synchronization environment using the abovedescribed general mechanism is shown in the flow diagram of FIG. 5A. At500, node A requests synchronization with node B, thereby asking node Bfor changes node A does not know about. In order to equip node B, at510, node A sends its knowledge to node B. At 520, node B compares theknowledge received from node A with its own knowledge to determine whatchanges node B knows about that should be sent to node A. At 530, node Bsends such changes to node A, and in addition, node B sends itsknowledge to node A so that node A can perform a similar knowledgecomparison at 540.

At 550, node A detects any potential conflicts between latest versionsreflected in the knowledge of node B and latest versions reflected inthe knowledge of node A, in the event that independent evolution ofversions has occurred on node A and node B. Optionally, any conflictresolution policy may be applied to determine which node trumps theother node in the event of a conflict. At 560, the latest changes fromnode A that are not possessed by node B are sent to node B. The conflictresolution policy will additionally dictate whether any changes are sentfrom node B to node A, or node A to node B, to maintain commoninformation between the nodes. If independent versioning is OK, ordesirable, no conflict resolution is another option.

FIG. 5B illustrates the generalized mechanism for exchanging knowledgewhen filtered knowledge is possible, i.e., where a subset of a node'sknowledge is to be synchronized with one or more of the other nodes. Asshown, each replica A and B has provider PA and provider PB,respectively. In this regard, each replica A and B maintains knowledgeK_(A) and K_(B), respectively, and potentially also maintains filteredknowledge F_(A) and F_(B). Similar to the case with no subsetting, anyof the replicas can request changes 570 of another replica and receivechanges 580 in response to the other replica conveying changes. If thefiltered knowledge F_(A) and filtered knowledge F_(B) are of the samescope, then as with the generalized knowledge exchange:

K _(A) =K _(A) ∪K _(B)

If the filtered knowledge F_(A) and filtered knowledge F_(B) are not ofthe same scope, then instead the knowledge is a function of existingknowledge plus the knowledge of the other replica as projected onto theintersection of their respective Filters F_(A) and F_(B), as follows:

K _(A) =K _(A)∪(K _(B)−(F _(A) ∪F _(B)))

Among other applications, an exemplary, non-limiting application forthese types of filters is for filtering columns, or any change units ofa synchronization framework. This is particularly applicable sincecolumn changes are not likely to be subject to move operations in thesystem. There are two considerations for this scenario worth noting:filter representation and knowledge consolidation.

With respect to filter representation, filter representation for thecase of no move filters is as follows. Each filter is represented as alist of the change units contained within the filter. Thisrepresentation provides a convenient means of representation as well asthe ability to combine filters when necessary. The ability to combinefilters is useful for consolidating knowledge.

With respect to knowledge consolidation, in order to keep knowledge inits most concise form the ability to consolidate knowledge must bemaintained. In this regard, fragments of filtered knowledge can beconsolidated so that knowledge can be maintained in its most compactform.

Considering the ability to combine filters, since filters can berepresented as a set of change units, overlaps in filters can bereconciled by isolating the sets of change units that exist in bothfilters.

Also, since the vector for a filter applies to each of the individualchange units within the filter, the combination of the filters can beperformed by finding the combined vector for the change unit for eachchange unit in both filters. Then once all of the vectors are known, thechange units that have a common vector are recombined into a new filter.

Accordingly, the notion of knowledge can be used to efficientlyrepresent data for knowledge exchanges among multiple nodes of amulti-master synchronization network, any node of which mayindependently evolve common information, or subsets of commoninformation, to be synchronized across the nodes. As described in moredetail below, the above-described knowledge based framework isextendible to a multi-master synchronization environment including Webservice endpoint(s).

Synchronization of Web Service Endpoints in a Multi-MasterSynchronization Environment

As mentioned, today, a variety of non-interoperable data synchronizationproducts exist, each connecting data from a few types of datarepositories to a few devices. Each protocol functions only for selectedtransports, and is implemented on a few devices. In this regard,existing synchronization products use different and diversecommunication protocols over the network. The proliferation ofnon-interoperable synchronization technologies complicates the tasks ofusers, device manufacturers, service providers, and applicationdevelopers. The lack of a common data synchronization protocol isimpeding growth in use of mobile devices, restricting users' ability toaccess data, and limiting the delivery of mobile data services.

Accordingly, a Web service (WS) synchronization protocol is providedthat sets forth the structure for metadata and the protocol by whichendpoints roam, share and synchronize in a multi-master ecosystem. UsingXML Web services, the protocol allows devices, services, andapplications to synchronize through firewalls and also allows forextensibility by not prescribing the schema of the actual data beingsynchronized. The invention also enables a variety of communicationscenarios for flexible messaging over Web services depending on thegoals of the nodes and symmetry of communications, e.g., pull, push orping to pull messaging scenarios. This also includes scenarios involvingprerequisite synchronization knowledge.

While Web services generically refers to any software system(s) designedto support interoperable machine to machine interaction over a network,Web services commonly refers to clients and servers that communicateusing extensible markup language (XML) messages that follow the simpleobject access protocol (SOAP) standard. This is illustrated generally inFIG. 6 as between service requester 600 (e.g. a client) and Web serviceprovider 610 (e.g., a server) beginning with a SOAP request from theservice requester 600, the request being handled by Web service provider610, and returning any SOAP messages in response according to Webservice communication protocols.

Additionally, it is typical of Web services definitions to include amachine readable description of the operations supported by the Webservice provider 610, a description in the Web Services DescriptionLanguage (WSDL), so that a service requester 600 can understand theservices provided by the Web service. A service broker 620 can includedescriptions of various Web service providers 610 and UniversalDescription, Discovery and Integration (UDDI) can be used to publishservice listings for discovery by service requesters 600 over networks.UDDI is one of the core Web services standards providing access to WSDLdocuments describing the protocol bindings and message formats requiredto interact with the web services listed in its directory.

Thus, a WS synchronization protocol for synchronizing data between twoendpoints is provided where at least one of the endpoints supports a Webservice. In various non-limiting embodiments, the invention provides ageneral SOAP-based protocol for synchronizing data between two endpointswhere at least one of the endpoints supports a Web service.

First, some notations, namespaces and terminology are set forth for thevarious non-limiting embodiments of the WS synchronization protocol ofthe invention. In this regard, the following syntax is used herein todefine normative outlines for messages according to the exemplarynon-limiting protocol specification presented below:

Below, syntax is represented as an XML instance. Characters are appendedto elements and attributes to indicate cardinality, as follows:

“?” (0 or 1)

“*” (0 or more)

“+” (1 or more)

The character “|” is used to indicate a choice between alternatives. Thecharacters “[” and “]” are used to indicate that contained items are tobe treated as a group with respect to cardinality or choice.

An ellipsis, i.e., “ . . . ”, indicates a point of extensibility thatallows other child or attribute content. Additional children and/orattributes may be added at the indicated extension points but shouldavoid contradicting the semantics of the parent and/or owner,respectively. If a receiver does not recognize an extension, thereceiver should avoid processing the message and may fault.

XML namespace prefixes are used to indicate the namespace of the elementbeing defined. In one embodiment, a SOAP node does not use an XMLnamespace identifier within SOAP envelopes unless it complies with theprotocol as defined in various non-limiting embodiments of theinvention.

Different types of data exchanges can be defined for differentsynchronization goals, e.g., pulling changes from a remote endpoint andpushing changes to a remote endpoint. While the scenario may exist wheretwo endpoints in a synchronization exchange can communicatesymmetrically, the various non-limiting embodiments of the protocol ofthe invention is mainly applicable to situations where only one of theendpoints exposes a Web service.

Pulling changes generally refers to a scenario where a client wishes toobtain data from a Web service host in order to obtain the knowledge ofthe Web service host.

Pushing changes generally refers to a scenario where a client wishes tosend its knowledge it has maintained locally to a Web Service.

Combining pushing and pulling scenarios results in a full knowledgeshare between the client and Web service endpoint. The scenarios mayalso include a notion of sending prerequisite knowledge along with a setof changes that have been made that are predicated on the prerequisiteknowledge.

As described above, knowledge is the ‘water mark’ for changeenumeration. Unlike anchors common to many synchronization systems, asdescribed above for generic knowledge exchanges among nodes, knowledgeis well defined and may be interpreted by any party involved in thesynchronization. Furthermore, since techniques are defined to accuratelycombine knowledge, it is not necessary to keep an instance of knowledgefor every partner synchronized. Rather, each endpoint keeps its ownlocal knowledge and merely adds to its local knowledge whenever itreceives changes from a remote endpoint. Advantageously, the protocolcan be used where the remote endpoint supports a Web service.

As shown in the block diagram of FIG. 7A, advantageously, an embodimentthe Web services synchronization protocol supports a variety ofmessaging patterns for exchanging knowledge in a multi-mastersynchronization environment leveraging the concepts of an efficientknowledge exchange as described above. In a first scenario, symmetricbilateral communications are assumed between a generic provider P of anode maintaining a replica A and knowledge K_(A) of replica A and a Webservices sync provider WSP of a Web services endpoint maintaining areplica B and knowledge K_(B) of replica B. When communications are not“blocked” one way or another, a knowledge exchange ensues by theprovider P requesting changes including sending its knowledge toProvider WSP at 700. In turn, provider WSP conveys changes to provider Pbased on the request at 710 including sending its knowledge to ProviderP. Any of the messaging scenarios herein can apply from the node side orthe Web service endpoint side, i.e., either side can make a request,though with Web services communications, it is noted the client mustinitiate synchronization requests whether pull or push operations.

As shown in FIG. 7B, another scenario is a “ping-to-pull” scenario.Rather than send the knowledge directly as part of an initial request,which can waste network bandwidth if unnecessary a ping 720 is performedfrom provider P to Web services provider SP, or vice versa, whereby theprovider WSP then determines whether any updates to its knowledge haveoccurred since a previous synchronization point. If so, then theprovider P is so informed and a knowledge exchange ensues according tosteps 730 and 740 as with FIG. 7A.

Another scenario, the push scenario, is depicted in FIG. 7C. In a blindpush, perhaps because of a trusted relationship, or other reason, thenode simply pushes its changes to the Web services endpoint provider WSPaccording to some predetermined criterion, e.g., whenever a changeoccurs, whenever a batch of changes occurs, periodically, etc. In thisregard, provider P provides its knowledge K_(A) to provider WSP at 750and the Web services endpoint either can incorporate the knowledge K_(A)into its knowledge K_(B) or the Web services endpoint disregards theattempt to convey changes if the knowledge is not new.

In yet another messaging scenario, shown in FIG. 7D, instead of a blindpush, provider P instead conveys its knowledge K_(A) and a set ofprerequisite knowledge PK_(A) that must be understood by provider WSP,or vice versa, in order to consume the knowledge K_(A) for validsynchronization purposes. Accordingly, the synchronizationcommunications are conditional on the recipient having a certain amountof knowledge already, or else the data is discarded. At that point, afull knowledge exchange may be required to synchronize with one another.

Having presented an overview of the operations on knowledge according toa synchronization framework for efficient representation ofsynchronization data a multi-master environment and various techniquesfor manipulating knowledge in the foregoing section and under differentmessaging scenarios, an exemplary, non-limiting implementation of theWeb service synchronization protocol is now presented. With the Webservice synchronization protocol, knowledge can be represented accordingto the following exemplary XML pseudo-structure.

  <Knowledge>  <ScopeVector>   <VectorEntry by=”...” sn=”...”/>  <VectorEntry by=”...” sn=”...”/>   <VectorEntry by=”...” sn=”...”/> </ScopeVector>  <RangeExceptio ns>   <Range lowerBound=”...”upperBound=”...”>    <VectorEntry by=”...” sn=”...”/>    <VectorEntryby=”...” sn=”...”/>    <VectorEntry by=”...” sn=”...”/>   </Range>  <Range>    ...   </Range>  </RangeExceptions>  <ItemExceptions>  <Item id=”...”>    <ItemVector>     <VectorEntry by=”...” sn=”...”/>    <VectorEntry by=”...” sn=”...”/>     <VectorEntry by=”...”sn=”...”/>    </ItemVector>   </Item>   <Item id=”...”>    <ChangeUnits>    <Unit id=”...”>      <VectorEntry by=”...” sn=”...”/>     <VectorEntry by=”...” sn=”...”/>      <VectorEntry by=”...”sn=”...”/>     </Unit>     <Unit id=”...”>      ...     </Unit>   </ChangeUnits>   </Item>  </ItemExceptions> </Knowledge>

The /Knowledge/ScopeVector in the XML representation contains theVectorClock that is applied to all items in the data set that contain aspecific override.

/Knowledge/RangeExceptions is a list of ranges with VectorClocks thatshould override the ScopeVector.

/Knowledge/RangeExceptions/Range:lowerBound in turn is the smallest itemcontained within the range.

/Knowledge/RangeExceptions/Range:upperBound represents the smallest itemlarger than the lowerBound that is not contained in the range.

/Knowledge/RangeExceptions/Range is a VectorClock that should be usedfor the range.

/Knowledge/ItemExceptions represents a list of items with either aVectorClock that should override the ScopeVector or a set of ChangeUnitswith an overriding VectorClock.

/Knowledge/ItemExceptions/Item represents the item specified by itsidentifier to which the exception applies.

/Knowledge/ItemExceptions/Item/ItemVector is a VectorClock thatoverrides any scope or range vector that would also apply to the item.

/Knowledge/ItemExceptions/ItemChangeUnits, if present, represents a listof change units contained within an item and an overriding VectorClockapplying to that change unit. Change units can be, for instance,properties of an item. They can be set/cleared but conform to a schemaand cannot be deleted.

/Knowledge/ItemExceptions/Item/ChangeUnits/Unit specifies the identifierand VectorClock that overrides any scope, range, or item vector thatwould also apply to the change unit.

A change batch is a grouping of changes that are communicated betweentwo synchronizing parties, and takes the following XML pseudo-structure.

  <ChangeBatch>  <PrerequisiteKnowledge> ... </PrerequisiteKnowledge><ChangeSet>   <MadeWithKnowledge>    ...   </MadeWithKnowledge>  <Changes>    <Change>     <ItemId>      </wsu:Address>      http://target/uri      </wsu:Address>     </ItemId>    <IsTombstone> Boolean </IsTombstone>     <BeginsRange> Boolean</BeginsRange>     <CreationVersion by=”...” sn=”...”/>    <UpdateVersion by=”...” sn=”...”/>     <ChangeUnits>      <Unit>      <UnitId>        <wsu:Address>         http://target/uri       </wsu:Address>       </UnitId>       <UpdateVersion .../>     </Unit>      ...     </ChangeUnits>    </Change>   </Changes> </ChangeSet>  ...  <MoreDataIsAvailable> Boolean </MoreDataIsAvailable></ChangeBatch>

In the above change batch pseudo-structure,/ChangeBatch/PrerequisiteKnowledge specifies a knowledge that is aprerequisite for the current batch of changes. This knowledge issubsumed by the knowledge of the endpoint receiving the changes.

/ChangeBatch/ChangeSet is a set of changes in the batch that share aMade With Knowledge.

/ChangeBatch/ChangeSet/MadeWithKnowledge is the knowledge that appliesto the change set. It is used for conflict detection as well as togenerate the knowledge fragment that can be added to the knowledge ofthe endpoint receiving the ChangeBatch.

/ChangeBatch/ChangeSet/Changes is the list of changes.

/ChangeBatch/ChangeSet/Changes/Change describes an individual change of/ChangeBatch/ChangeSet/Changes.

/ChangeBatch/ChangeSet/Changes/Change/ItemId is the sync identifier forthe item being sent. Providers can also optimize by including the actualdata in this message (link or embedded) using the Address element

/ChangeBatch/ChangeSet/Changes/Change/IsTombstone is a flag indicatingwhether this is metadata representing an item that has been deleted.

/ChangeBatch/ChangeSet/Changes/Change/BeginsRange is a flag indicatingwhether this item is the first in a continuous sequence of items.

/ChangeBatch/ChangeSet/Changes/Change/CreationVersion is the versionthat the item was given when it entered the scope.

/ChangeBatch/ChangeSet/Changes/Change/UpdateVersion, if present, is theversion of the item being communicated in this change batch.

/ChangeBatch/ChangeSet/Changes/Change/ChangeUnits, if present, is a listof change units contained within the item.

/ChangeBatch/ChangeSet/Changes/Change/ChangeUnits/Unit describes aspecific change unit within the item.

/ChangeBatch/ChangeSet/Changes/Change/ChangeUnits/Unit/UnitId is theidentifier for the change unit. Similar to the Change/ItemId field, thiscan be used to either embed or link the data using the Address element.

/ChangeBatch/ChangeSet/Changes/Change/ChangeUnits/Unit/Update Version isthe version of the change unit within the item being communicated inthis change batch.

/ChangeBatch/MoreDataIsAvailable is a flag that indicates that allchanges known to the source between the PrerequisiteKnowledge and theMadeWithKnowledge are contained within the batch.

With respect to messaging of the synchronization protocol, aGetKnowledge message is a message that can be sent by device nodes tothe Web service endpoint to obtain a copy of the current knowledge ofthe service, and has the following exemplary XML pseudo-structure.

  <GetKnowledge>  <ScopeReplica>   http://scope/replica/uri </ScopeReplica> </GetKnowledge> /GetKnowledge/ScopeReplica

GetKnowledge defines information relevant to the service that allows theservice to identify the target data to be synchronized. Web serviceproviders use the URI to fully resolve the logical set of items beingsynchronized, e.g., “4-star music”, “Videos”, “Public Contacts”, etc.

The GetKnowledgeResponse message is the response to from the Web serviceto the GetKnowledge message, containing a snapshot of the knowledge forthe service, and has the following exemplary XML pseudo-structure.

  <GetKnowledgeResponse>  <ScopeReplica>   http://scope/replica/uri </ScopeReplica>  <Knowledge>   ...  </Knowledge></GetKnowledgeResponse>

/GetKnowledgeResponse/ScopeReplica defines information relevant to theservice that allows it to identify the target data to be synchronized.

/GetKnowledgeResponse/Knowledge is the Knowledge of the service for thegiven Scope-Replica.

The RequestChanges message is sent to the Web service to request thatthe service enumerate a batch of changes and return it, and has thefollowing exemplary XML pseudo-structure.

  <RequestChanges>  <ScopeReplica>   http://scope/replica/uri </ScopeReplica>  <Knowledge>   ...  </Knowledge>  <RequestParamsEnumerateAllItems  OnForgottenKnowledgeFailure=true> </RequestChanges>

/RequestChanges/ScopeReplica defines information relevant to the servicethat allows it to identify the target data to be synchronized.

/RequestChanges/Knowledge is the Knowledge of the client that theservice should as a basis to enumerate changes.

/RequestChanges/RequestParams/EnumerateAllItemsOnForgottenKnowledgeFailureis a flag that indicates, if the client's knowledge fails to subsume theforgotten knowledge of the server, that the server should enumerate allitems in its store allowing the client to cleanup deleted items.

The RequestChangesResponse message is the response to RequestChanges,containing a change batch with all of the changes within the batch. ThePrerequisiteKnowledge within the ChangeBatch is the knowledge that wassent as part of the RequestChanges message.

  <RequestChangesResponse>  <ScopeReplica>   http://scope/replica/uri </ScopeReplica>  <ChangeBatch>   ...  </ChangeBatch> <FullItemSetEnumerated> Boolean </FullItemSetEnumerated> <ForgottenKnowledge>   ...  </ForgottenKnowledge></RequestChangesResponse>

/RequestChangesResponse/ScopeReplica defines information relevant to theservice that allows it to identify the target data to be synchronized.

/RequestChangesResponse/ChangeBatch is a batch of the changes identifiedby the service that need to be returned to the client.

/RequestChangesResponse/FullItemSetEnumerated is a flag indicating thatthe change batch contains a full enumeration of items in theScope-Replica of the service due to a forgotten knowledge check failure.

In the case of a full enumeration,/RequestChangesResponse/ForgottenKnowledge is the forgotten knowledge ofthe service that should be learned by the client with the batch ofchanges.

The ConveyChanges message is sent to the service when a set of changesis being pushed to the service. The knowledge that is sent in theChangeBatch is the knowledge that was used for enumeration. It couldhave been obtained by either a call to GetKnowledge or as a cached copyobtained through previous sync messages, and takes the followingexemplary XML pseudo-structure.

  <ConveyChanges>  <ScopeReplica>   http://scope/replica/uri </ScopeReplica>  <ChangeBatch>   ...  </ChangeBatch> <ForgottenKnowledge>   ...  </ForgottenKnowledge> <FullItemSetEnumerated> Boolean </FullItemSetEnumerated></ConveyChanges>

/ConveyChanges/ScopeReplica defines information relevant to the servicethat allows it to identify the target data to be synchronized.

/ConveyChanges/ChangeBatch is a batch of the changes identified by theclient that need to be applied to the service.

/ConveyChanges/FullItemSetEnumerated is a flag indicating that thechange batch contains a full enumeration of items in the Scope-Replicaof the client due to a forgotten knowledge check failure.

In the case of a full enumeration, /ConveyChanges/ForgottenKnowledge isthe forgotten knowledge of the client that should be learned by theservice with the batch of changes.

The ConveyChangesResponse message is the response to the ConveyChangesmessage, containing the knowledge on the Web service as a result of theapplication of changes, and has the following exemplary XMLpseudo-structure.

  <ConveyChangesResponse>  <ScopeReplica>   http://scope/replica/uri </ScopeReplica>  <ResultingKnowledge>   ...  </ResultingKnowledge></ConveyChangesResponse>

/ConveyChangesResponse/ScopeReplica defines information relevant to theservice that allows it to identify the target data to be synchronized.

/ConveyChangesResponse/ResultingKnowledge is the knowledge of theservice after application of the conveyed change batch.

A Web service synchronization protocol is thus provided that sets forththe metadata and messaging by which endpoints roam, share andsynchronize common information with one another in a multi-masternetworked computing ecosystem.

A general SOAP-based protocol is defined for synchronizing data betweentwo endpoints where one or more of the endpoints supports a Web service.Defining messaging for knowledge-based transfers using XML Web services,the protocol allows devices, services and applications to synchronizethrough firewalls, allows for flexibility by allowing any common set orsubset of information across endpoints and allows for extensibility bynot prescribing the schema of the actual data being synchronized at theendpoints.

FIG. 8 illustrates that the knowledge based framework for synchronizingsets or subsets of common information among nodes and/or Web serviceendpoints in a multi-master synchronization environment enables thenodes and/or Web service endpoints to store the same data with differentschema. While the different endpoints must negotiate a commonrepresentation for schema elements being synchronized, i.e., thesynchronization protocol is data type agnostic in terms of itsrepresentation of knowledge and thus each node can store the underlyingschema elements according to its own wishes.

As illustrated a node, e.g., PCI may include a first schema S1 forrepresenting contact objects whereas a Web service endpoint WSE maystore contact objects according to a different schema S2. In thisregard, because the efficient representation of knowledge is notdependent on the type of data being synchronized, different devices canmake different decisions about which knowledge, e.g., which subsets ofknowledge to consume.

FIG. 9 is a flow diagram of an exemplary, non-limiting method forexchanging knowledge between a node and a Web service in accordance withnon-limiting embodiments of the protocol of the invention. However, asmade clear from FIGS. 7A, 7B, 7C and 7D, the invention is not limited tothe full knowledge exchange pattern represented by FIG. 9, but ratherping to pull, pull and push scenarios, as well as prerequisite knowledgescenarios are all contemplated in accordance with a flexiblesynchronization protocol.

At 900, a node request changes from the Web service. At 910, the nodesends its knowledge to the Web service. At 920, the Web service comparesits knowledge to Node knowledge. At 930, the Web service sends thelatest changes from the Web service to the node of which the node isunaware. Also, the node receives the knowledge of the Web service for acomparison to its own knowledge at 940. At 950, conflicts between anyindependently evolved changes in the node's knowledge and the Webservice's knowledge are detected. Lastly, at 960, the latest changes aresent to the Web service from the node of which the Web service isunaware. The knowledge analysis thus enables an efficient knowledgeexchange by only sending the changes that the other endpoint requestsand does not have already.

FIG. 10 is a block diagram of an exemplary non-limiting implementationof a device 1000 b for performing a full or partial knowledge exchange.As shown, device 1000 b includes a sync module 1020 that performs thefull or partial knowledge exchange techniques for synchronizing a set ofobjects 1030 with another device in accordance with non-limitingembodiments of the invention. Sync module 1020 may include a synccommunications module 1022 for generally transmitting and receiving datain accordance with the knowledge exchange techniques of non-limitingembodiments of the invention.

Sync communications module 1022 may also include a sync initiationmodule 1022 a which may initiate synchronization with a second device ifauthorized, e.g., via authorization module 1040, and connect to thesecond device. Sync module 1020 may also include an I/O module 1022 bresponsive to the initiation of synchronization by sending full and/orpartial knowledge 1002 b about the set of objects 1030 to the seconddevice (not shown) and for receiving back full and/or partial knowledge1012 b of the second device and changes to be made to the set of objects1030 originating from the second device. In turn, a sync analysis module1024 operates to apply the changes to be made to the set of objects 1030and to compare full and/or partial knowledge 1012 b from the seconddevice with the full and/or partial knowledge 1002 b of the first devicein order to determine changes to send to the second device to completesynchronization between the devices.

Supplemental Context Regarding Web Services

The specifications that define Web services are intentionally modular,and as a result there is no one document that contains them all.Additionally, there is neither a single, nor a stable set ofspecifications. Generally speaking, there are a few “core”specifications that are supplemented by others as the circumstances andchoice of technology dictate, including: XML, SOAP, WSDL and UDDI

Simple Object Access Protocol (SOAP) is an XML-based, extensible messageenvelope format, with “bindings” to underlying protocols. SOAP is aprotocol for exchanging XML-based messages over computer networks,normally using Hyper Text Transfer Protocol (HTTP)/HTTP Secure (HTTPS).SOAP forms the foundation layer of the Web services stack, providing abasic messaging framework that more abstract layers can build on.

There are several different types of messaging patterns in SOAP, but byfar the most common is the Remote Procedure Call (RPC) pattern, in whichone network node (the client) sends a request message to another node(the server), and the server immediately sends a response message to theclient. Using SOAP over HTTP allows for easier communication behindproxies and firewalls than previous remote execution technology.

SOAP is versatile enough to allow for the use of different transportprotocols. The standard stacks use HTTP as a transport protocol, butother protocols are also usable (TCP, SNMP).

WSDL is an XML format that allows service interfaces to be described,along with the details of their bindings to specific protocols and istypically used to generate server and client code, and forconfiguration.

Universal Description, Discovery and Integration (UDDI) is a protocolfor publishing and discovering metadata about Web services, to enableapplications to find Web services, either at design time or runtime.UDDI is an open industry initiative enabling businesses to publishservice listings and discover each other and define how the services orsoftware applications interact over the Internet. A UDDI businessregistration consists of three components:

White Pages—address, contact, and known identifiers;

Yellow Pages—industrial categorizations based on standard taxonomies;

Green Pages—technical information about services exposed by thebusiness.

UDDI is one of the core Web services standards. It is designed to beinterrogated by SOAP messages and to provide access to WSDL documentsdescribing the protocol bindings and message formats required tointeract with the web services listed in its directory.

Exemplary Networked and Distributed Environments

One of ordinary skill in the art can appreciate that the variousnon-limiting embodiments for synchronization knowledge representationand exchange with Web service endpoint(s) described above can beimplemented in connection with any computer or other client or serverdevice, which can be deployed as part of a computer network, or in adistributed computing environment, connected to any kind of data store.In this regard, the present invention pertains to any computer system orenvironment having any number of memory or storage units, and any numberof applications and processes occurring across any number of storageunits or volumes, which may be used in connection with synchronizationtechniques in accordance with the present invention. The presentinvention may apply to an environment with server computers and clientcomputers deployed in a network environment or a distributed computingenvironment, having remote or local storage. The present invention mayalso be applied to standalone computing devices, having programminglanguage functionality, interpretation and execution capabilities forgenerating, receiving and transmitting information in connection withremote or local services and processes.

Distributed computing provides sharing of computer resources andservices by exchange between computing devices and systems. Theseresources and services include the exchange of information, cachestorage and disk storage for objects, such as files. Distributedcomputing takes advantage of network connectivity, allowing clients toleverage their collective power to benefit the entire enterprise. Inthis regard, a variety of devices may have applications, objects orresources that may implicate the systems and methods for synchronizingin accordance with the invention.

FIG. 11 provides a schematic diagram of an exemplary networked ordistributed computing environment. The distributed computing environmentcomprises computing objects 1110 a, 1110 b, etc. and computing objectsor devices 1120 a, 1120 b, 1120 c, 1120 d, 1120 e, etc. These objectsmay comprise programs, methods, data stores, programmable logic, etc.The objects may comprise portions of the same or different devices suchas PDAs, audio/video devices, MP3 players, personal computers, etc. Eachobject can communicate with another object by way of the communicationsnetwork 1140. This network may itself comprise other computing objectsand computing devices that provide services to the system of FIG. 11,and may itself represent multiple interconnected networks. In accordancewith an aspect of the invention, each object 1110 a, 1110 b, etc. or1120 a, 1120 b, 1120 c, 1120 d, 1120 e, etc. may contain an applicationthat might make use of an API, or other object, software, firmwareand/or hardware, suitable for use with the systems and methods forsynchronizing with knowledge in accordance with the invention.

It can also be appreciated that an object, such as 1120 c, may be hostedon another computing device 1110 a, 1110 b, etc. or 1120 a, 1120 b, 1120c, 1120 d, 1120 e, etc. Thus, although the physical environment depictedmay show the connected devices as computers, such illustration is merelyexemplary and the physical environment may alternatively be depicted ordescribed comprising various digital devices such as PDAs, televisions,MP3 players, etc., any of which may employ a variety of wired andwireless services, software objects such as interfaces, COM objects, andthe like.

There are a variety of systems, components, and network configurationsthat support distributed computing environments. For example, computingsystems may be connected together by wired or wireless systems, by localnetworks or widely distributed networks. Currently, many of the networksare coupled to the Internet, which provides an infrastructure for widelydistributed computing and encompasses many different networks. Any ofthe infrastructures may be used for exemplary communications madeincident to synchronizing according to the present invention.

In home networking environments, there are at least four disparatenetwork transport media that may each support a unique protocol, such asPower line, data (both wireless and wired), voice (e.g., telephone) andentertainment media. Most home control devices such as light switchesand appliances may use power lines for connectivity. Data Services mayenter the home as broadband (e.g., either DSL or Cable modem) and areaccessible within the home using either wireless (e.g., HomeRF or802.11B) or wired (e.g., Home PNA, Cat 5, Ethernet, even power line)connectivity. Voice traffic may enter the home either as wired (e.g.,Cat 3) or wireless (e.g., cell phones) and may be distributed within thehome using Cat 3 wiring. Entertainment media, or other graphical data,may enter the home either through satellite or cable and is typicallydistributed in the home using coaxial cable. IEEE 1394 and DVI are alsodigital interconnects for clusters of media devices. All of thesenetwork environments and others that may emerge, or already haveemerged, as protocol standards may be interconnected to form a network,such as an intranet, that may be connected to the outside world by wayof a wide area network, such as the Internet. In short, a variety ofdisparate sources exist for the storage and transmission of data, andconsequently, any of the computing devices of the present invention mayshare and communicate data in any existing manner, and no one waydescribed in the embodiments herein is intended to be limiting.

The Internet commonly refers to the collection of networks and gatewaysthat utilize the Transmission Control Protocol/Internet Protocol(TCP/IP) suite of protocols, which are well-known in the art of computernetworking. The Internet can be described as a system of geographicallydistributed remote computer networks interconnected by computersexecuting networking protocols that allow users to interact and shareinformation over network(s). Because of such wide-spread informationsharing, remote networks such as the Internet have thus far generallyevolved into an open system with which developers can design softwareapplications for performing specialized operations or services,essentially without restriction.

Thus, the network infrastructure enables a host of network topologiessuch as client/server, peer-to-peer, or hybrid architectures. The“client” is a member of a class or group that uses the services ofanother class or group to which it is not related. Thus, in computing, aclient is a process, i.e., roughly a set of instructions or tasks, thatrequests a service provided by another program. The client processutilizes the requested service without having to “know” any workingdetails about the other program or the service itself. In aclient/server architecture, particularly a networked system, a client isusually a computer that accesses shared network resources provided byanother computer, e.g., a server. In the illustration of FIG. 11, as anexample, computers 1120 a, 1120 b, 1120 c, 1120 d, 1120 e, etc. can bethought of as clients and computers 1110 a, 1110 b, etc. can be thoughtof as servers where servers 1110 a, 1110 b, etc. maintain the data thatis then replicated to client computers 1120 a, 1120 b, 1120 c, 1120 d,1120 e, etc., although any computer can be considered a client, aserver, or both, depending on the circumstances. Any of these computingdevices may be processing data or requesting services or tasks that mayimplicate the synchronization techniques with knowledge in accordancewith the invention.

A server is typically a remote computer system accessible over a remoteor local network, such as the Internet or wireless networkinfrastructures. The client process may be active in a first computersystem, and the server process may be active in a second computersystem, communicating with one another over a communications medium,thus providing distributed functionality and allowing multiple clientsto take advantage of the information-gathering capabilities of theserver. Any software objects utilized pursuant to the techniques forsynchronizing based on knowledge in accordance with the invention may bedistributed across multiple computing devices or objects.

Client(s) and server(s) communicate with one another utilizing thefunctionality provided by protocol layer(s). For example, HyperTextTransfer Protocol (HTTP) is a common protocol that is used inconjunction with the World Wide Web (WWW), or “the Web.” Typically, acomputer network address such as an Internet Protocol (IP) address orother reference such as a Universal Resource Locator (URL) can be usedto identify the server or client computers to each other. The networkaddress can be referred to as a URL address. Communication can beprovided over a communications medium, e.g., client(s) and server(s) maybe coupled to one another via TCP/IP connection(s) for high-capacitycommunication.

Thus, FIG. 11 illustrates an exemplary networked or distributedenvironment, with server(s) in communication with client computer (s)via a network/bus, in which the present invention may be employed. Inmore detail, a number of servers 1110 a, 1110 b, etc. are interconnectedvia a communications network/bus 1140, which may be a LAN, WAN,intranet, GSM network, the Internet, etc., with a number of client orremote computing devices 1120 a, 1120 b, 1120 c, 1120 d, 1120 e, etc.,such as a portable computer, handheld computer, thin client, networkedappliance, or other device, such as a VCR, TV, oven, light, heater andthe like in accordance with the present invention. It is thuscontemplated that the present invention may apply to any computingdevice in connection with which it is desirable to synchronize any kindof data.

In a network environment in which the communications network/bus 1140 isthe Internet, for example, the servers 1110 a, 1110 b, etc. can be Webservers with which the clients 1120 a, 1120 b, 1120 c, 1120 d, 1120 e,etc. communicate via any of a number of known protocols such as HTTP.Servers 1110 a, 1110 b, etc. may also serve as clients 1120 a, 1120 b,1120 c, 1120 d, 1120 e, etc., as may be characteristic of a distributedcomputing environment.

As mentioned, communications may be wired or wireless, or a combination,where appropriate. Client devices 1120 a, 1120 b, 1120 c, 1120 d, 1120e, etc. may or may not communicate via communications network/bus 1140,and may have independent communications associated therewith. Forexample, in the case of a TV or VCR, there may or may not be a networkedaspect to the control thereof. Each client computer 1120 a, 1120 b, 1120c, 1120 d, 1120 e, etc. and server computer 1110 a, 1110 b, etc. may beequipped with various application program modules or objects 1135 a,1135 b, 1135 c, etc. and with connections or access to various types ofstorage elements or objects, across which files or data streams may bestored or to which portion(s) of files or data streams may bedownloaded, transmitted or migrated. Any one or more of computers 1110a, 1110 b, 1120 a, 1120 b, 1120 c, 1120 d, 1120 e, etc. may beresponsible for the maintenance and updating of a database 1130 or otherstorage element, such as a database or memory 1130 for storing dataprocessed or saved according to the invention. Thus, the presentinvention can be utilized in a computer network environment havingclient computers 1120 a, 1120 b, 1120 c, 1120 d, 1120 e, etc. that canaccess and interact with a computer network/bus 1140 and servercomputers 1110 a, 1110 b, etc. that may interact with client computers1120 a, 1120 b, 1120 c, 1120 d, 1120 e, etc. and other like devices, anddatabases 1130.

Exemplary Computing Device

As mentioned, the invention applies to any device wherein it may bedesirable to synchronize any kind of data across a set of devices. Itshould be understood, therefore, that handheld, portable and othercomputing devices and computing objects of all kinds are contemplatedfor use in connection with the present invention, i.e., anywhere that adevice may benefit from sharing of data across devices or otherwisereceive, process or store data. Accordingly, the below general purposeremote computer described below in FIG. 12 is but one example, and thepresent invention may be implemented with any client having network/businteroperability and interaction. Thus, the present invention may beimplemented in an environment of networked hosted services in which verylittle or minimal client resources are implicated, e.g., a networkedenvironment in which the client device serves merely as an interface tothe network/bus, such as an object placed in an appliance.

Although not required, the invention can partly be implemented via anoperating system, for use by a developer of services for a device orobject, and/or included within application software that operates inconnection with the component(s) of the invention. Software may bedescribed in the general context of computer-executable instructions,such as program modules, being executed by one or more computers, suchas client workstations, servers or other devices. Those skilled in theart will appreciate that the invention may be practiced with othercomputer system configurations and protocols.

FIG. 12 thus illustrates an example of a suitable computing systemenvironment 1200 a in which the invention may be implemented, althoughas made clear above, the computing system environment 1200 a is only oneexample of a suitable computing environment for a media device and isnot intended to suggest any limitation as to the scope of use orfunctionality of the invention. Neither should the computing environment1200 a be interpreted as having any dependency or requirement relatingto any one or combination of components illustrated in the exemplaryoperating environment 1200 a.

With reference to FIG. 12, an exemplary remote device for implementingthe invention includes a general purpose computing device in the form ofa computer 1210 a. Components of computer 1210 a may include, but arenot limited to, a processing unit 1220 a, a system memory 1230 a, and asystem bus 1221 a that couples various system components including thesystem memory to the processing unit 1220 a. The system bus 1221 a maybe any of several types of bus structures including a memory bus ormemory controller, a peripheral bus, and a local bus using any of avariety of bus architectures.

Computer 1210 a typically includes a variety of computer readable media.Computer readable media can be any available media that can be accessedby computer 1210 a. By way of example, and not limitation, computerreadable media may comprise computer storage media and communicationmedia. Computer storage media includes both volatile and nonvolatile,removable and non-removable media implemented in any method ortechnology for storage of information such as computer readableinstructions, data structures, program modules or other data. Computerstorage media includes, but is not limited to, RAM, ROM, EEPROM, flashmemory or other memory technology, CDROM, digital versatile disks (DVD)or other optical disk storage, magnetic cassettes, magnetic tape,magnetic disk storage or other magnetic storage devices, or any othermedium which can be used to store the desired information and which canbe accessed by computer 1210 a. Communication media typically embodiescomputer readable instructions, data structures, program modules orother data in a modulated data signal such as a carrier wave or othertransport mechanism and includes any information delivery media.

The system memory 1230 a may include computer storage media in the formof volatile and/or nonvolatile memory such as read only memory (ROM)and/or random access memory (RAM). A basic input/output system (BIOS),containing the basic routines that help to transfer information betweenelements within computer 1210 a, such as during start-up, may be storedin memory 1230 a. Memory 1230 a typically also contains data and/orprogram modules that are immediately accessible to and/or presentlybeing operated on by processing unit 1220 a. By way of example, and notlimitation, memory 1230 a may also include an operating system,application programs, other program modules, and program data.

The computer 1210 a may also include other removable/non-removable,volatile/nonvolatile computer storage media. For example, computer 1210a could include a hard disk drive that reads from or writes tonon-removable, nonvolatile magnetic media, a magnetic disk drive thatreads from or writes to a removable, nonvolatile magnetic disk, and/oran optical disk drive that reads from or writes to a removable,nonvolatile optical disk, such as a CD-ROM or other optical media. Otherremovable/non-removable, volatile/nonvolatile computer storage mediathat can be used in the exemplary operating environment include, but arenot limited to, magnetic tape cassettes, flash memory cards, digitalversatile disks, digital video tape, solid state RAM, solid state ROMand the like. A hard disk drive is typically connected to the system bus1221 a through a non-removable memory interface such as an interface,and a magnetic disk drive or optical disk drive is typically connectedto the system bus 1221 a by a removable memory interface, such as aninterface.

A user may enter commands and information into the computer 1210 athrough input devices such as a keyboard and pointing device, commonlyreferred to as a mouse, trackball or touch pad. Other input devices mayinclude a microphone, joystick, game pad, satellite dish, scanner, orthe like. These and other input devices are often connected to theprocessing unit 1220 a through user input 1240 a and associatedinterface(s) that are coupled to the system bus 1221 a, but may beconnected by other interface and bus structures, such as a parallelport, game port or a universal serial bus (USB). A graphics subsystemmay also be connected to the system bus 1221 a. A monitor or other typeof display device is also connected to the system bus 1221 a via aninterface, such as output interface 1250 a, which may in turncommunicate with video memory. In addition to a monitor, computers mayalso include other peripheral output devices such as speakers and aprinter, which may be connected through output interface 1250 a.

The computer 1210 a may operate in a networked or distributedenvironment using logical connections to one or more other remotecomputers, such as remote computer 1270 a, which may in turn have mediacapabilities different from device 1210 a. The remote computer 1270 amay be a personal computer, a server, a router, a network PC, a peerdevice or other common network node, or any other remote mediaconsumption or transmission device, and may include any or all of theelements described above relative to the computer 1210 a. The logicalconnections depicted in FIG. 12 include a network 1271 a, such localarea network (LAN) or a wide area network (WAN), but may also includeother networks/buses. Such networking environments are commonplace inhomes, offices, enterprise-wide computer networks, intranets and theInternet.

When used in a LAN networking environment, the computer 1210 a isconnected to the LAN 1271 a through a network interface or adapter. Whenused in a WAN networking environment, the computer 1210 a typicallyincludes a communications component, such as a modem, or other means forestablishing communications over the WAN, such as the Internet. Acommunications component, such as a modem, which may be internal orexternal, may be connected to the system bus 1221 a via the user inputinterface of input 1240 a, or other appropriate mechanism. In anetworked environment, program modules depicted relative to the computer1210 a, or portions thereof, may be stored in a remote memory storagedevice. It will be appreciated that the network connections shown anddescribed are exemplary and other means of establishing a communicationslink between the computers may be used.

There are multiple ways of implementing the present invention, e.g., anappropriate API, tool kit, driver code, operating system, control,standalone or downloadable software object, etc. which enablesapplications and services to use the systems and methods forrepresenting and exchanging knowledge in accordance with the invention.The invention contemplates the use of the invention from the standpointof an API (or other software object), as well as from a software orhardware object that performs the knowledge exchange in accordance withthe invention. Thus, various implementations of the invention describedherein may have aspects that are wholly in hardware, partly in hardwareand partly in software, as well as in software.

The word “exemplary” is used herein to mean serving as an example,instance, or illustration. For the avoidance of doubt, the subjectmatter disclosed herein is not limited by such examples. In addition,any aspect or design described herein as “exemplary” is not necessarilyto be construed as preferred or advantageous over other aspects ordesigns, nor is it meant to preclude equivalent exemplary structures andtechniques known to those of ordinary skill in the art. Furthermore, tothe extent that the terms “includes,” “has,” “contains,” and othersimilar words are used in either the detailed description or the claims,for the avoidance of doubt, such terms are intended to be inclusive in amanner similar to the term “comprising” as an open transition wordwithout precluding any additional or other elements.

As mentioned above, while exemplary embodiments of the present inventionhave been described in connection with various computing devices andnetwork architectures, the underlying concepts may be applied to anycomputing device or system in which it is desirable to synchronize datawith another computing device or system. For instance, thesynchronization processes of the invention may be applied to theoperating system of a computing device, provided as a separate object onthe device, as part of another object, as a reusable control, as adownloadable object from a server, as a “middle man” between a device orobject and the network, as a distributed object, as hardware, in memory,a combination of any of the foregoing, etc.

As mentioned, the various techniques described herein may be implementedin connection with hardware or software or, where appropriate, with acombination of both. As used herein, the terms “component,” “system” andthe like are likewise intended to refer to a computer-related entity,either hardware, a combination of hardware and software, software, orsoftware in execution. For example, a component may be, but is notlimited to being, a process running on a processor, a processor, anobject, an executable, a thread of execution, a program, and/or acomputer. By way of illustration, both an application running oncomputer and the computer can be a component. One or more components mayreside within a process and/or thread of execution and a component maybe localized on one computer and/or distributed between two or morecomputers.

Thus, the methods and apparatus of the present invention, or certainaspects or portions thereof, may take the form of program code (i.e.,instructions) embodied in tangible media, such as floppy diskettes,CD-ROMs, hard drives, or any other machine-readable storage medium,wherein, when the program code is loaded into and executed by a machine,such as a computer, the machine becomes an apparatus for practicing theinvention. In the case of program code execution on programmablecomputers, the computing device generally includes a processor, astorage medium readable by the processor (including volatile andnon-volatile memory and/or storage elements), at least one input device,and at least one output device. One or more programs that may implementor utilize the synchronization services and/or processes of the presentinvention, e.g., through the use of a data processing API, reusablecontrols, or the like, are preferably implemented in a high levelprocedural or object oriented programming language to communicate with acomputer system. However, the program(s) can be implemented in assemblyor machine language, if desired. In any case, the language may be acompiled or interpreted language, and combined with hardwareimplementations.

The methods and apparatus of the present invention may also be practicedvia communications embodied in the form of program code that istransmitted over some transmission medium, such as over electricalwiring or cabling, through fiber optics, or via any other form oftransmission, wherein, when the program code is received and loaded intoand executed by a machine, such as an EPROM, a gate array, aprogrammable logic device (PLD), a client computer, etc., the machinebecomes an apparatus for practicing the invention. When implemented on ageneral-purpose processor, the program code combines with the processorto provide a unique apparatus that operates to invoke the functionalityof the present invention. Additionally, any storage techniques used inconnection with the present invention may invariably be a combination ofhardware and software.

Furthermore, the disclosed subject matter may be implemented as asystem, method, apparatus, or article of manufacture using standardprogramming and/or engineering techniques to produce software, firmware,hardware, or any combination thereof to control a computer or processorbased device to implement aspects detailed herein. The term “article ofmanufacture” (or alternatively, “computer program product”) where usedherein is intended to encompass a computer program accessible from anycomputer-readable device, carrier, or media. For example, computerreadable media can include but are not limited to magnetic storagedevices (e.g., hard disk, floppy disk, magnetic strips . . . ), opticaldisks (e.g., compact disk (CD), digital versatile disk (DVD) . . . ),smart cards, and flash memory devices (e.g., card, stick). Additionally,it is known that a carrier wave can be employed to carrycomputer-readable electronic data such as those used in transmitting andreceiving electronic mail or in accessing a network such as the Internetor a local area network (LAN).

The aforementioned systems have been described with respect tointeraction between several components. It can be appreciated that suchsystems and components can include those components or specifiedsub-components, some of the specified components or sub-components,and/or additional components, and according to various permutations andcombinations of the foregoing. Sub-components can also be implemented ascomponents communicatively coupled to other components rather thanincluded within parent components (hierarchical). Additionally, itshould be noted that one or more components may be combined into asingle component providing aggregate functionality or divided intoseveral separate sub-components, and any one or more middle layers, suchas a management layer, may be provided to communicatively couple to suchsub-components in order to provide integrated functionality. Anycomponents described herein may also interact with one or more othercomponents not specifically described herein but generally known bythose of skill in the art.

In view of the exemplary systems described supra, methodologies that maybe implemented in accordance with the disclosed subject matter will bebetter appreciated with reference to the flowcharts of the figures.While for purposes of simplicity of explanation, the methodologies areshown and described as a series of blocks, it is to be understood andappreciated that the claimed subject matter is not limited by the orderof the blocks, as some blocks may occur in different orders and/orconcurrently with other blocks from what is depicted and describedherein. Where non-sequential, or branched, flow is illustrated viaflowchart, it can be appreciated that various other branches, flowpaths, and orders of the blocks, may be implemented which achieve thesame or a similar result. Moreover, not all illustrated blocks may berequired to implement the methodologies described hereinafter.

Furthermore, as will be appreciated various portions of the disclosedsystems above and methods below may include or consist of artificialintelligence or knowledge or rule based components, sub-components,processes, means, methodologies, or mechanisms (e.g., support vectormachines, neural networks, expert systems, Bayesian belief networks,fuzzy logic, data fusion engines, classifiers . . . ). Such components,inter alia, can automate certain mechanisms or processes performedthereby to make portions of the systems and methods more adaptive aswell as efficient and intelligent.

While the present invention has been described in connection with thepreferred embodiments of the various figures, it is to be understoodthat other similar embodiments may be used or modifications andadditions may be made to the described embodiment for performing thesame function of the present invention without deviating therefrom. Forexample, while exemplary network environments of the invention aredescribed in the context of a networked environment, such as a peer topeer networked environment, one skilled in the art will recognize thatthe present invention is not limited thereto, and that the methods, asdescribed in the present application may apply to any computing deviceor environment, such as a gaming console, handheld computer, portablecomputer, etc., whether wired or wireless, and may be applied to anynumber of such computing devices connected via a communications network,and interacting across the network. Furthermore, it should be emphasizedthat a variety of computer platforms, including handheld deviceoperating systems and other application specific operating systems arecontemplated, especially as the number of wireless networked devicescontinues to proliferate.

While exemplary embodiments refer to utilizing the present invention inthe context of particular programming language constructs, the inventionis not so limited, but rather may be implemented in any language toprovide methods for representing and exchanging knowledge for a set ofnodes in accordance with the invention. Still further, the presentinvention may be implemented in or across a plurality of processingchips or devices, and storage may similarly be effected across aplurality of devices. Therefore, the present invention should not belimited to any single embodiment, but rather should be construed inbreadth and scope in accordance with the appended claims.

What is claimed is:
 1. A method for data synchronization between aplurality of nodes communicatively coupled via one or more networks,comprising: at an intermediate node, receiving knowledge informationregarding data, the knowledge information received from an originatingnode and including a version representation of the data at theoriginating node; and propagating the knowledge information includingthe version representation of the data at the originating node to adifferent node via the intermediate node.
 2. The method of claim 1,wherein the propagating is performed while the intermediate node isconnected to the originating node.
 3. The method of claim 1, wherein thepropagating is performed while the originating node is not connected tothe different node.
 4. The method of claim 1, further comprisingreceiving at the intermediate node from the originating node changes tothe data of which the intermediate node is not aware, wherein thepropagating comprises propagating the changes to the different node viathe intermediate node.
 5. The method of claim 1, further comprisingreceiving at the intermediate node from the different node knowledgeinformation concerning the data at the different node and a versionrepresentation of the data at the different node.
 6. The method of claim5, further comprising comparing the knowledge information received fromthe different node with the knowledge information received from theoriginating node to determine what changes to the data to propagate tothe different node of which the different node is unaware.
 7. The methodof claim 5, further comprising comparing the knowledge informationreceived from the different node with the knowledge information receivedfrom the originating node to determine what changes to the data topropagate to the originating node of which the originating node isunaware.
 8. The method of claim 1, wherein at least one of theoriginating node, the intermediate node, or the different node isconfigured to support a Web service.
 9. The method of claim 8, whereinthe propagating comprises defining messaging for knowledge-basedtransfers using extensible markup language (XML) Web services.
 10. Asystem configured to synchronize data between a plurality of nodescommunicatively coupled via one or more networks, comprising: areceiving component configured to receive, at an intermediate node,knowledge information regarding data, the knowledge information receivedfrom an originating node and including a version representation of thedata at the originating node; and a synchronization component configuredto propagate the knowledge information including the versionrepresentation of the data at the originating node to a different nodevia the intermediate node.
 11. The system of claim 10, wherein thesynchronization component is configured to propagate the knowledgeinformation from the originating node to the different node via theintermediate node while the intermediate node is connected to theoriginating node.
 12. The system of claim 10, wherein thesynchronization component is configured to propagate the knowledgeinformation from the originating node to the different node via theintermediate node while the originating node is not connected to thedifferent node.
 13. The system of claim 10, wherein at least one of theoriginating node, the intermediate node, or the different node isconfigured to support a Web service.
 14. The system of claim 13, whereinthe synchronization component is configured to define messaging forknowledge-based transfers using extensible markup language (XML) Webservices.
 15. The system of claim 10, the receiving component configuredto accrue collective knowledge information regarding the data, whereinthe collective knowledge information is node-independent synchronizationknowledge of the data.
 16. A computer-readable storage medium configuredto synchronize data between a plurality of nodes communicatively coupledvia one or more networks, the computer-readable storage mediumcomprising computer-readable instructions for causing at least oneprocessor to execute the following acts: at an intermediate node,receiving knowledge information regarding data, the knowledgeinformation received from an originating node and including a versionrepresentation of the data at the originating node; and propagating theknowledge information including the version representation of the dataat the originating node to a different node via the intermediate node.17. The computer-readable storage medium of claim 16, wherein the actsfurther comprise comparing knowledge information received from thedifferent node with the knowledge information received from theoriginating node to determine what changes to the data to propagate tothe different node of which the different node is unaware.
 18. Thecomputer-readable storage medium of claim 16, wherein the acts furthercomprise comparing knowledge information received from the differentnode with the knowledge information received from the originating nodeto determine what changes to the data to propagate to the originatingnode of which the originating node is unaware.
 19. The computer-readablestorage medium of claim 16, wherein at least one of the originatingnode, the intermediate node, or the different node is configured tosupport a Web service.
 20. The computer-readable storage medium of claim19, wherein the propagating comprises defining messaging forknowledge-based transfers using extensible markup language (XML) Webservices.